Methods and systems for analyzing entity performance

ABSTRACT

Approaches for analyzing entity performance are disclosed. A first set of data and a second set of data can be stored in a data structure. This data can be associated with a plurality of interactions, and can be modified to include additional interactions. These interactions can involve consuming entities and provisioning entities. The modified data structure can be queried to retrieve information associated with one or more entities. After information is retrieved, it can be provided to a user.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of prior application Ser. No. 14/800,447, filed Jul. 15, 2015, entitled “METHODS AND SYSTEMS FOR ANALYZING ENTITY PERFORMANCE,” which claims the benefit of U.S. Provisional Application No. 62/160,541, filed May 12, 2015, entitled “METHODS AND SYSTEMS FOR ANALYZING ENTITY PERFORMANCE,” each of which is incorporated by reference herein in its entirety.

BRIEF DESCRIPTION OF THE DRAWINGS

Reference will now be made to the accompanying drawings, which illustrate exemplary embodiments of the present disclosure and in which:

FIG. 1 illustrates, in block diagram form, an exemplary data fusion system for providing interactive data analysis, consistent with embodiments of the present disclosure.

FIG. 2 is a block diagram of an exemplary system for analyzing performance of an entity, consistent with embodiments of the present disclosure.

FIG. 3 is a block diagram of an exemplary computer system, consistent with embodiments of the present disclosure.

FIG. 4 is a block diagram of an exemplary data structure accessed in the process of analyzing entity performance, consistent with the embodiments of the present disclosure.

FIG. 5 is a block diagram of an exemplary scenario depicting a system for analyzing entity performance, consistent with the embodiments of the present disclosure.

FIG. 6 is a block diagram of an exemplary system for analyzing entity performance, consistent with the embodiments of the present disclosure.

FIG. 7 is an illustration of an example display, consistent with the embodiments of the present disclosure.

FIG. 8 is a flowchart representing an exemplary process for querying a data structure, consistent with embodiments of the present disclosure.

DETAILED DESCRIPTION OF EXEMPLARY EMBODIMENTS

Reference will now be made in detail to exemplary embodiments, the examples of which are illustrated in the accompanying drawings. Whenever possible, the same reference numbers will be used throughout the drawings to refer to the same or like parts.

Generally, embodiments of the invention relate to analyzing entity performance in real-time based on interactions (e.g., anonymized credit card or debit card transaction data) and potentially other data (e.g., merchant data). Types of interactions from which entity performance may be derived include, e.g., purchases made at a brick-and-mortar store or purchases made online. Large sets of interaction data may be filtered according to selectable criteria to provide, for example, information associated with the performance of a particular entity (e.g., a merchant). Such selectable criteria may include an amount spent at a particular location, times of purchases, time spent between purchases, types of merchants associated with purchase, demographics associated with a purchaser, purchaser identity, demographics associated with a location of a merchant, Merchant Category Codes (MCCs), types of products purchases, etc. In addition, the performance of the entity may be expressed in terms of tables, charts, graphs, or other visual aids, which illustrate performance in terms of revenue, wallet share, time, expenses, etc.

In some embodiments, data relating to the interactions may be stored in a real-time distributed computation environment that supports stream-oriented processing. For example, the data can be stored in a data structure using Hadoop's Distributed File System, Vertica™, or Amazon™ S3. In some embodiments, the data structure storing the interactions data may be incrementally updated at particular intervals by a data computation system, such as Apache's Spark™, providing a user with real-time or near real-time information about the interactions.

In one example, a first data stream including information associated with credit and debit card interactions is acquired at a data computation system and/or a data structure. This stream can include information relating to over three-hundred million transactions per day, for example. This stream can be divided into smaller streams. As an example, a particular interaction data stream may be divided into separate sub-streams, each based on a unique provisioning entity (e.g., a merchant). In addition, a second stream may be acquired that includes interaction information from a point-of-sale system. Different data streams or additional streams can also be acquired.

In some embodiments, the data streams can be segmented by a data computation system to include information associated with new customers (e.g., by determining whether the consuming entity, or information associated therewith, is included in the data structure), returning customers (e.g., by determining whether a consuming entity makes a purchase at a provisioning entity at least twice within a particular amount of time), determining a home location associated with an individual based on transaction data (e.g., anonymized credit card transaction data), local customers, and non-local customers. The aggregation of interaction information associated with these streams can be incrementally updated in the data structure in real-time, allowing a user to access a business portal and view a day-by-day, year-by-year, or even minute-by-minute break down of revenues generated, locations of interactions, etc.

Additional aspects relating to the invention may include different queries that can be run, and how they are registered with the data computation system. For example, in some embodiments the queries are registered with the system a priori in order to walk through a data set that is constantly being updated. For example, a query could be entered by a user into a graphical user interface and cause a data computation system to retrieve a plurality of merchants within a particular radius that sell pizza and have revenue over a particular amount for the instant day. Next, if a new merchant exceeds the queried amount later that day, as additional streams of information associated with interactions are received or otherwise become available, then that new merchant may be added to a table or other user interface in real-time such that someone using the system could see that the new merchant was also within the ambit of the predetermined query.

FIG. 1 illustrates, in block diagram form, an exemplary data fusion system 100 for providing interactive data analysis, consistent with embodiments of the present disclosure. Among other things, data fusion system 100 facilitates transformation of one or more data sources, such as data sources 130 (e.g., financial services systems 220, geographic data systems 230, provisioning entity management systems 240 and/or consuming entity data systems 250, as shown in FIG. 2) into an object model 160 whose semantics are defined by an ontology 150. The transformation can be performed for a variety of reasons. For example, a database administrator can import data from data sources 130 into a database 170 for persistently storing object model 160. As another example, a data presentation component (not depicted) can transform input data from data sources 130 “on the fly” into object model 160. The object model 160 can then be utilized, in conjunction with ontology 150, for analysis through graphs and/or other data visualization techniques.

Data fusion system 100 comprises a definition component 110 and a translation component 120, both implemented by one or more processors of one or more computing devices or systems executing hardware and/or software-based logic for providing various functionality and features of the present disclosure, as described herein. As will be appreciated from the present disclosure, data fusion system 100 can comprise fewer or additional components that provide the various functionalities and features described herein. Moreover, the number and arrangement of the components of data fusion system 100 responsible for providing the various functionalities and features described herein can further vary from embodiment to embodiment.

Definition component 110 generates and/or modifies ontology 150 and a schema map 140. Exemplary embodiments for defining an ontology (such as ontology 150) are described in U.S. Pat. No. 7,962,495 (the '495 patent), issued on Jun. 14, 2011, the entire contents of which are expressly incorporated herein by reference for all purposes. Consistent with certain embodiments disclosed in the '495 patent, a dynamic ontology may be used to create a database. To create a database ontology, one or more object types may be defined, where each object type includes one or more properties. The attributes of object types or property types of the ontology can be edited or modified at any time. And, for each property type, at least one parser definition may be created. The attributes of a parser definition can be edited or modified at any time.

In some embodiments, each property type is declared to be representative of one or more object types. A property type is representative of an object type when the property type is intuitively associated with the object type. Alternatively, each property type has one or more components and a base type. In some embodiments, a property type can comprise a string, a date, a number, or a composite type consisting of two or more string, date, or number elements. Thus, property types are extensible and can represent complex data structures. Further, a parser definition can reference a component of a complex property type as a unit or token.

An example of a property having multiple components is an Address property having a City component and a State component. An example of raw input data is “Los Angeles, Calif.” An example parser definition specifies an association of imported input data to object property components as follows: {CITY}, {STATE}→Address: State, Address: City. In some embodiments, the association {CITY}, {STATE} is defined in a parser definition using regular expression symbology. The association {CITY}, {STATE} indicates that a city string followed by a state string, and separated by a comma, comprises valid input data for a property of type Address. In contrast, input data of “Los Angeles Calif.” would not be valid for the specified parser definition, but a user could create a second parser definition that does match input data of “Los Angeles Calif.” The definition Address: City, Address: State specifies that matching input data values map to components named “City” and “State” of the Address property. As a result, parsing the input data using the parser definition results in assigning the value “Los Angeles” to the Address: City component of the Address property, and the value “CA” to the Address: State component of the Address property.

According to some embodiments, schema map 140 can define how various elements of schemas 135 for data sources 130 map to various elements of ontology 150. Definition component 110 receives, calculates, extracts, or otherwise identifies schemas 135 for data sources 130. Schemas 135 define the structure of data sources 130; for example, the names and other characteristics of tables, files, columns, fields, properties, and so forth. Definition component 110 furthermore optionally identifies sample data 136 from data sources 130. Definition component 110 can further identify object type, relationship, and property definitions from ontology 150, if any already exist. Definition component 110 can further identify pre-existing mappings from schema map 140, if such mappings exist.

Based on the identified information, definition component 110 can generate a graphical user interface 115. Graphical user interface 115 can be presented to users of a computing device via any suitable output mechanism (e.g., a display screen, an image projection, etc.), and can further accept input from users of the computing device via any suitable input mechanism (e.g., a keyboard, a mouse, a touch screen interface, etc.). Graphical user interface 115 features a visual workspace that visually depicts representations of the elements of ontology 150 for which mappings are defined in schema map 140.

In some embodiments, transformation component 120 can be invoked after schema map 140 and ontology 150 have been defined or redefined. Transformation component 120 identifies schema map 140 and ontology 150. Transformation component 120 further reads data sources 130 and identifies schemas 135 for data sources 130. For each element of ontology 150 described in schema map 140, transformation component 120 iterates through some or all of the data items of data sources 130, generating elements of object model 160 in the manner specified by schema map 140. In some embodiments, transformation component 120 can store a representation of each generated element of object model 160 in a database 170. In some embodiments, transformation component 120 is further configured to synchronize changes in object model 160 back to data sources 130.

Data sources 130 can be one or more sources of data, including, without limitation, spreadsheet files, databases, email folders, document collections, media collections, contact directories, and so forth. Data sources 130 can include data structures stored persistently in non-volatile memory. Data sources 130 can also or alternatively include temporary data structures generated from underlying data sources via data extraction components, such as a result set returned from a database server executing a database query.

Schema map 140, ontology 150, and schemas 135 can be stored in any suitable structures, such as XML files, database tables, and so forth. In some embodiments, ontology 150 is maintained persistently. Schema map 140 can or cannot be maintained persistently, depending on whether the transformation process is perpetual or a one-time event. Schemas 135 need not be maintained in persistent memory, but can be cached for optimization.

Object model 160 comprises collections of elements such as typed objects, properties, and relationships. The collections can be structured in any suitable manner. In some embodiments, a database 170 stores the elements of object model 160, or representations thereof. Alternatively, the elements of object model 160 are stored within database 170 in a different underlying format, such as in a series of object, property, and relationship tables in a relational database.

According to some embodiments, the functionalities, techniques, and components described herein are implemented by one or more special-purpose computing devices. The special-purpose computing devices can be hard-wired to perform the techniques, or can include digital electronic devices such as one or more application-specific integrated circuits (ASICs) or field programmable gate arrays (FPGAs) that are persistently programmed to perform the techniques, or can include one or more general purpose hardware processors programmed to perform the techniques pursuant to program instructions in firmware, memory, other storage, or a combination. Such special-purpose computing devices can also combine custom hard-wired logic, ASICs, or FPGAs with custom programming to accomplish the techniques. The special-purpose computing devices can be desktop computer systems, portable computer systems, handheld devices, networking devices, or any other device that incorporates hard-wired and/or program logic to implement the techniques.

Throughout this disclosure, reference will be made to an entity such as, for example, a provisioning entity and a consuming entity. It will be understood that a provisioning entity can include, for example, a merchant, a retail provisioning entity or the like, and a consuming entity can include, for example, a consumer user buying products or services from a provisioning entity. It will be understood that a consuming entity can represent either individual persons or can represent a group of persons (e.g., a group of persons living under one roof as part of a family). In some embodiments, a consuming entity can be a credit card number of an individual or a credit card number for an entire family sharing one credit card. It will also be understood that a provisioning entity can represent either the entity itself or individual persons involved with the entity.

In embodiments described herein, data fusion system 100 can provide a provisioning entity, such as a retail provisioning entity, to analyze information to identify behaviors to allow that provisioning entity to make more informed decisions. Such information can allow retail entities, such as a retail provisioning entity, to determine where to place their retail locations. Provisioning entities having more than one location (e.g., a merchant with a chain store or a franchise model) typically evaluate the performance of their locations and may adjust their business models or work flows when the locations under-perform. Typically, provisioning entities evaluate the performance of their locations based on period-to-period metrics. For example, a provisioning entity can evaluate a location's performance by comparing the current month's sales to the previous month's sales. In addition, provisioning entitles can evaluate each of its locations' performance using comparative analysis. For example, a provisioning entity might compare the sales at an area location with the sales at a second location. As provisioning entities generally measure the performance of its locations based on their own interaction data (e.g., the entity's sales across some or all of its locations), current methods of measuring performance do not consider sales made by competitors or demographic features of the areas of the provisioning entity's locations.

Since current performance evaluation methods do not consider the sales of competitors or the demographic features of the region of the provisioning entity location, measured performance may not represent the true performance of a provisioning entity. For instance, although a provisioning entity location in a low consumer spend capacity area might have less sales than a provisioning entity location in a high consumer spend capacity area, it may be performing better than what could be expected for that area in light of, for example, the low number of consumers residing in the area or the low income of the area. A performance of a provisioning entity at an area location can be adversely impacted by the close proximity of a second location of the provisioning entity, but the provisioning entity at the area location can be performing better than expected given the competition from the provisioning entity's second location. Conversely, while a provisioning entity location in a dense, high-income area might have the highest sales of all provisioning entity locations, it can still be under-performing because, for instance, consumer spend capacity is high and the provisioning entity location could generate more sales.

Consistent with embodiments of the present disclosure, the performance of provisioning entities can be analyzed based on how the provisioning entity is expected to perform given the location of the provisioning entity. For a given provisioning entity location, the disclosed embodiments may be implemented to consider, for example, consumer demographic features of the provisioning entity location's area and the proximity of competitors to the provisioning entity location (including the proximity of the provisioning entity's other close-by locations). In some embodiments, the provisioning entity can be a merchant. For purposes of illustration, exemplary embodiments for analyzing entity performance are described herein with reference to “merchants.” The exemplary embodiments and techniques described herein, however, may be applied to other types of entities (e.g., service providers, governmental agencies, etc.) within the spirit and scope of this disclosure.

FIG. 2 is a block diagram of an exemplary system 200 for performing one or more operations for analyzing performance of a provisioning entity and/or a consuming entity, consistent with disclosed embodiments. In some embodiments, the provisioning entity is a merchant and system 200 can include provisioning entity analysis system 210, one or more financial services systems 220, one or more geographic data systems 230, one or more provisioning entity management systems 240, and one or more consuming entity data systems 250. The components and arrangement of the components included in system 200 can vary depending on the embodiment. For example, the functionality described below with respect to financial services systems 220 can be embodied in consuming entity data systems 250, or vice-versa. Thus, system 200 can include fewer or additional components that perform or assist in the performance of one or more processes to analyze provisioning entity's, consistent with the disclosed embodiments.

One or more components of system 200 can be computing systems configured to analyze provisioning entity performance. As further described herein, components of system 200 can include one or more computing devices (e.g., computer(s), server(s), etc.), memory storing data and/or software instructions (e.g., database(s), memory devices, etc.), and other appropriate computing components. In some embodiments, the one or more computing devices are configured to execute software or a set of programmable instructions stored on one or more memory devices to perform one or more operations, consistent with the disclosed embodiments. Components of system 200 can be configured to communicate with one or more other components of system 200, including provisioning entity analysis system 210, one or more financial services systems 220, one or more geographic data systems 230, one or more provisioning entity management systems 240, and one or more consumer data systems 250. In certain aspects, users can operate one or more components of system 200. The one or more users can be employees of, or associated with, the entity corresponding to the respective component(s) (e.g., someone authorized to use the underlying computing systems or otherwise act on behalf of the entity).

Provisioning entity analysis system 210 can be a computing system configured to analyze provisioning entity performance. For example, provisioning entity analysis system 210 can be a computer system configured to execute software or a set of programmable instructions that collect or receive financial interaction data, consumer data, and provisioning entity data and process it to determine the actual transaction amount of each transaction associated with the provisioning entity. Provisioning entity analysis system 210 can be configured, in some embodiments, to utilize, include, or be a data fusion system 100 (see, e.g., FIG. 1) to transform data from various data sources (such as, financial services systems 220, geographic data systems 230, provisioning entity management systems 240, and consuming entity data systems 250) for processing. In some embodiments, provisioning entity analysis system 210 can be implemented using a computer system 300, as shown in FIG. 3 and described below.

Provisioning entity analysis system 210 can include one or more computing devices (e.g., server(s)), memory storing data and/or software instructions (e.g., database(s), memory devices, etc.) and other known computing components. According to some embodiments, provisioning entity analysis system 210 can include one or more networked computers that execute processing in parallel or use a distributed computing architecture. Provisioning entity analysis system 210 can be configured to communicate with one or more components of system 200, and it can be configured to provide analysis of provisioning entities via an interface(s) accessible by users over a network (e.g., the Internet). For example, provisioning entity analysis system 210 can include a web server that hosts a web page accessible through network 260 by provisioning entity management systems 240. In some embodiments, provisioning entity analysis system 210 can include an application server configured to provide data to one or more client applications executing on computing systems connected to provisioning entity analysis system 210 via network 260.

In some embodiments, provisioning entity analysis system 210 can be configured to determine the actual sales for a provisioning entity or specific provisioning entity location by processing and analyzing data collected from one or more components of system 200. For example, provisioning entity analysis system 210 can determine that the Big Box Merchant store located at 123 Main St, in Burbank, Calif. is actually generating $60,000 of sales per month. Provisioning entity analysis system 210 can provide an analysis of a provisioning entity or provisioning entity location's performance based on a target for sales and the actual sales for the provisioning entity or provisioning entity location. For example, for the Big Box Merchant store located at 123 Main St., Burbank, Calif., the provisioning entity analysis system 210 can provide an analysis that the store is performing above expectations.

Provisioning entity analysis system 210 can, in some embodiments, generate a user interface communicating data related to one or more provisioning entities or provisioning entity locations. For example, in some embodiments, provisioning entity analysis system 210 includes a web server that generates HTML code, or scripts capable of generating HTML code, that can be displayed in a web browser executing on computing device. Provisioning entity analysis system 210 can also execute an application server that provides user interface objects to a client application executing on a computing device, or it can provide data that is capable of being displayed in a user interface in a client application executing on a computing device. In some embodiments, provisioning entity analysis system 210 can generate user interfaces that can be displayed within another user interface. For example, provisioning entity analysis system 210 can generate a user interface for display within a parent user interface that is part of a word processing application, a presentation development application, a web browser, or an illustration application, among others. In some embodiments, generating a user interface can include generating the code that when executed displays information (e.g., HTML) on the user interface. Alternatively, generating a user interface can include providing commands and/or data to a set of instructions that when executed render a user interface capable of being shown on a display connected to a computing device. In some embodiments, the user interface can include a map, indications of the provisioning entity locations on a map, and indications of the sales or interactions associated with the provisioning entity locations.

Referring again to FIG. 2, financial services system 220 can be a computing system associated with a financial service provider, such as a bank, credit card issuer, credit bureau, credit agency, or other entity that generates, provides, manages, and/or maintains financial service accounts for one or more users. Financial services system 220 can generate, maintain, store, provide, and/or process financial data associated with one or more financial service accounts. Financial data can include, for example, financial service account data, such as financial service account identification data, account balance, available credit, existing fees, reward points, user profile information, and financial service account interaction data, such as interaction dates, interaction amounts, interaction types, and location of interaction. In some embodiments, each interaction of financial data can include several categories of information associated with the interaction. For example, each interaction can include categories such as number category; consuming entity identification category; consuming entity location category; provisioning entity identification category; provisioning entity location category; type of provisioning entity category; interaction amount category; and time of interaction category, as described in FIG. 4. It will be appreciated that financial data can comprise either additional or fewer categories than the exemplary categories listed above. Financial services system 220 can include infrastructure and components that are configured to generate and/or provide financial service accounts such as credit card accounts, checking accounts, savings account, debit card accounts, loyalty or reward programs, lines of credit, and the like.

Geographic data systems 230 can include one or more computing devices configured to provide geographic data to other computing systems in system 200 such as provisioning entity analysis system 210. For example, geographic data systems 230 can provide geodetic coordinates when provided with a street address of vice-versa. In some embodiments, geographic data systems 230 exposes an application programming interface (API) including one or more methods or functions that can be called remotely over a network, such as network 260. According to some embodiments, geographic data systems 230 can provide information concerning routes between two geographic points. For example, provisioning entity analysis system 210 can provide two addresses and geographic data systems 230 can provide, in response, the aerial distance between the two addresses, the distance between the two addresses using roads, and/or a suggested route between the two addresses and the route's distance.

According to some embodiments, geographic data systems 230 can also provide map data to provisioning entity analysis system 210 and/or other components of system 200. The map data can include, for example, satellite or overhead images of a geographic region or a graphic representing a geographic region. The map data can also include points of interest, such as landmarks, malls, shopping centers, schools, or popular restaurants or retailers, for example.

Provisioning entity management systems 240 can be one or more computing devices configured to perform one or more operations consistent with disclosed embodiments. For example, provisioning entity management systems 240 can be a desktop computer, a laptop, a server, a mobile device (e.g., tablet, smart phone, etc.), or any other type of computing device configured to request provisioning entity analysis from provisioning entity analysis system 210. According to some embodiments, provisioning entity management systems 240 can comprise a network-enabled computing device operably connected to one or more other presentation devices, which can themselves constitute a computing system. For example, provisioning entity management systems 240 can be connected to a mobile device, telephone, laptop, tablet, or other computing device.

Provisioning entity management systems 240 can include one or more processors configured to execute software instructions stored in memory. Provisioning entity management systems 240 can include software or a set of programmable instructions that when executed by a processor performs known Internet-related communication and content presentation processes. For example, provisioning entity management systems 240 can execute software or a set of instructions that generates and displays interfaces and/or content on a presentation device included in, or connected to, provisioning entity management systems 240. In some embodiments, provisioning entity management systems 240 can be a mobile device that executes mobile device applications and/or mobile device communication software that allows provisioning entity management systems 240 to communicate with components of system 200 over network 260. The disclosed embodiments are not limited to any particular configuration of provisioning entity management systems 240.

Provisioning entity management systems 240 can be one or more computing systems associated with a provisioning entity that provides products (e.g., goods and/or services), such as a restaurant (e.g., Outback Steakhouse®, Burger King®, etc.), retailer (e.g., Amazon.com®, Target®, etc.), grocery store, mall, shopping center, service provider (e.g., utility company, insurance company, financial service provider, automobile repair services, movie theater, etc.), non-profit organization (ACLU™, AARP®, etc.) or any other type of entity that provides goods, services, and/or information that consuming entities (i.e., end-users or other business entities) can purchase, consume, use, etc. For ease of discussion, the exemplary embodiments presented herein relate to purchase interactions involving goods from retail provisioning entity systems. Provisioning entity management systems 240, however, is not limited to systems associated with retail provisioning entities that conduct business in any particular industry or field.

Provisioning entity management systems 240 can be associated with computer systems installed and used at a brick and mortar provisioning entity locations where a consumer can physically visit and purchase goods and services. Such locations can include computing devices that perform financial service interactions with consumers (e.g., Point of Sale (POS) terminal(s), kiosks, etc.). Provisioning entity management systems 240 can also include back- and/or front-end computing components that store data and execute software or a set of instructions to perform operations consistent with disclosed embodiments, such as computers that are operated by employees of the provisioning entity (e.g., back office systems, etc.). Provisioning entity management systems 240 can also be associated with a provisioning entity that provides goods and/or service via known online or e-commerce types of solutions. For example, such a provisioning entity can sell products via a website using known online or e-commerce systems and solutions to market, sell, and process online interactions. Provisioning entity management systems 240 can include one or more servers that are configured to execute stored software or a set of instructions to perform operations associated with a provisioning entity, including one or more processes associated with processing purchase interactions, generating interaction data, generating product data (e.g., SKU data) relating to purchase interactions, for example.

Consuming entity data systems 250 can include one or more computing devices configured to provide demographic data regarding consumers. For example, consuming entity data systems 250 can provide information regarding the name, address, gender, income level, age, email address, or other information about consumers. Consuming entity data systems 250 can include public computing systems such as computing systems affiliated with the U.S. Bureau of the Census, the U.S. Bureau of Labor Statistics, or FedStats, or it can include private computing systems such as computing systems affiliated with financial institutions, credit bureaus, social media sites, marketing services, or some other organization that collects and provides demographic data.

Network 260 can be any type of network or combination of networks configured to provide electronic communications between components of system 200. For example, network 260 can be any type of network (including infrastructure) that provides communications, exchanges information, and/or facilitates the exchange of information, such as the Internet, a Local Area Network, or other suitable connection(s) that enables the sending and receiving of information between the components of system 200. Network 260 may also comprise any combination of wired and wireless networks. In other embodiments, one or more components of system 200 can communicate directly through a dedicated communication link(s), such as links between provisioning entity analysis system 210, financial services system 220, geographic data systems 230, provisioning entity management systems 240, and consuming entity data systems 250.

As noted above, provisioning entity analysis system 210 can include a data fusion system (e.g., data fusion system 100) for organizing data received from one or more of the components of system 200.

FIG. 3 is a block diagram of an exemplary computer system 300, consistent with embodiments of the present disclosure. The components of system 200 such as provisioning entity analysis system 210, financial service systems 220, geographic data systems 230, provisioning entity management systems 240, and consuming entity data systems 250 may include the architecture based on or similar to that of computer system 300.

As illustrated in FIG. 3, computer system 300 includes a bus 302 or other communication mechanism for communicating information, and one or more hardware processors 304 (denoted as processor 304 for purposes of simplicity) coupled with bus 302 for processing information. Hardware processor 304 can be, for example, one or more general-purpose microprocessors or it can be a reduced instruction set of one or more microprocessors.

Computer system 300 also includes a main memory 306, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 302 for storing information and instructions to be executed by processor 304. Main memory 306 also can be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor 304. Such instructions, after being stored in non-transitory storage media accessible to processor 304, render computer system 300 into a special-purpose machine that is customized to perform the operations specified in the instructions.

Computer system 300 further includes a read only memory (ROM) 308 or other static storage device coupled to bus 302 for storing static information and instructions for processor 304. A storage device 310, such as a magnetic disk, optical disk, or USB thumb drive (Flash drive), etc. is provided and coupled to bus 302 for storing information and instructions.

Computer system 300 can be coupled via bus 302 to a display 312, such as a cathode ray tube (CRT), liquid crystal display, or touch screen, for displaying information to a computer user. An input device 314, including alphanumeric and other keys, is coupled to bus 302 for communicating information and command selections to processor 304. Another type of user input device is cursor control 316, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor 304 and for controlling cursor movement on display 312. The input device typically has two degrees of freedom in two axes, a first axis (for example, x) and a second axis (for example, y), that allows the device to specify positions in a plane. In some embodiments, the same direction information and command selections as cursor control can be implemented via receiving touches on a touch screen without a cursor.

Computing system 300 can include a user interface module to implement a graphical user interface that can be stored in a mass storage device as executable software codes that are executed by the one or more computing devices. This and other modules can include, by way of example, components, such as software components, object-oriented software components, class components and task components, processes, functions, attributes, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuitry, data, databases, data structures, tables, arrays, and variables.

In general, the word “module,” as used herein, refers to logic embodied in hardware or firmware, or to a collection of software instructions, possibly having entry and exit points, written in a programming language, such as, for example, Java, Lua, C or C++. A software module can be compiled and linked into an executable program, installed in a dynamic link library, or written in an interpreted programming language such as, for example, BASIC, Perl, or Python. It will be appreciated that software modules can be callable from other modules or from themselves, and/or can be invoked in response to detected events or interrupts. Software modules configured for execution on computing devices can be provided on a computer readable medium, such as a compact disc, digital video disc, flash drive, magnetic disc, or any other tangible medium, or as a digital download (and can be originally stored in a compressed or installable format that requires installation, decompression, or decryption prior to execution). Such software code can be stored, partially or fully, on a memory device of the executing computing device, for execution by the computing device. Software instructions can be embedded in firmware, such as an EPROM. It will be further appreciated that hardware modules can be comprised of connected logic units, such as gates and flip-flops, and/or can be comprised of programmable units, such as programmable gate arrays or processors. The modules or computing device functionality described herein are preferably implemented as software modules, but can be represented in hardware or firmware. Generally, the modules described herein refer to logical modules that can be combined with other modules or divided into sub-modules despite their physical organization or storage.

Computer system 300 can implement the techniques described herein using customized hard-wired logic, one or more ASICs or FPGAs, firmware and/or program logic which in combination with the computer system causes or programs computer system 300 to be a special-purpose machine. According to some embodiments, the operations, functionalities, and techniques and other features described herein are performed by computer system 300 in response to processor 304 executing one or more sequences of one or more instructions contained in main memory 306. Such instructions can be read into main memory 306 from another storage medium, such as storage device 310. Execution of the sequences of instructions contained in main memory 306 causes processor 304 to perform the process steps described herein. In alternative embodiments, hard-wired circuitry can be used in place of or in combination with software instructions.

The term “non-transitory media” as used herein refers to any non-transitory media storing data and/or instructions that cause a machine to operate in a specific fashion. Such non-transitory media can comprise non-volatile media and/or volatile media. Non-volatile media can include, for example, optical or magnetic disks, such as storage device 310. Volatile media can include dynamic memory, such as main memory 306. Common forms of non-transitory media can include, for example, a floppy disk, a flexible disk, hard disk, solid state drive, magnetic tape, or any other magnetic data storage medium, a CD-ROM, any other optical data storage medium, any physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, NVRAM, any other memory chip or cartridge, and networked versions of the same.

Non-transitory media is distinct from, but can be used in conjunction with, transmission media. Transmission media can participate in transferring information between storage media. For example, transmission media can include coaxial cables, copper wire and fiber optics, including the wires that comprise bus 302. Transmission media can also take the form of acoustic or light waves, such as those generated during radio-wave and infra-red data communications.

Various forms of media can be involved in carrying one or more sequences of one or more instructions to processor 304 for execution. For example, the instructions can initially be carried on a magnetic disk or solid state drive of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system 300 can receive the data on the telephone line and use an infra-red transmitter to convert the data to an infra-red signal. An infra-red detector can receive the data carried in the infra-red signal and appropriate circuitry can place the data on bus 302. Bus 302 carries the data to main memory 306, from which processor 304 retrieves and executes the instructions. The instructions received by main memory 306 can optionally be stored on storage device 310 either before or after execution by processor 304.

Computer system 300 can also include a communication interface 318 coupled to bus 302. Communication interface 318 can provide a two-way data communication coupling to a network link 320 that can be connected to a local network 322. For example, communication interface 318 can be an integrated services digital network (ISDN) card, cable modem, satellite modem, or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 318 can be a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links can also be implemented. In any such implementation, communication interface 318 can send and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.

Network link 320 can typically provide data communication through one or more networks to other data devices. For example, network link 320 can provide a connection through local network 322 to a host computer 324 or to data equipment operated by an Internet Service Provider (ISP) 326. ISP 326 in turn can provide data communication services through the world wide packet data communication network now commonly referred to as the “Internet” 328. Local network 322 and Internet 328 can both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 320 and through communication interface 318, which carry the digital data to and from computer system 300, can be example forms of transmission media.

Computer system 300 can send messages and receive data, including program code, through the network(s), network link 320 and communication interface 318. In the Internet example, a server 330 can transmit a requested code for an application program through Internet 328, ISP 326, local network 322 and communication interface 318. The received code can be executed by processor 304 as it is received, and/or stored in storage device 310, or other non-volatile storage for later execution. In some embodiments, server 330 can provide information for being displayed on a display.

FIG. 4 is a block diagram of an exemplary data structure 400, consistent with embodiments of the present disclosure. Data structure 400 can store data records associated with interactions involving multiple entities. Data structure 400 can be, for example, a database (e.g., database 170) that can store elements of an object model (e.g., object model 160). In some embodiments, data structure 400 can be a Relational Database Management System (RDBMS) that stores interaction data as sections of rows of data in relational tables. An RDBMS can be designed to efficiently return data for an entire row, or record, in as few operations as possible. An RDBMS can store data by serializing each row of data of data structure 400. For example, in an RDBMS, data associated with interaction 1 of FIG. 4 can be stored serially such that data associated with all categories of interaction 1 can be accessed in one operation.

Alternatively, data structure 400 can be a column-oriented database management system that stores data as sections of columns of data rather than rows of data. This column-oriented DBMS can have advantages, for example, for data warehouses, customer relationship management systems, and library card catalogs, and other ad hoc inquiry systems where aggregates are computed over large numbers of similar data items. A column-oriented DBMS can be more efficient than an RDBMS when an aggregate needs to be computed over many rows but only for a notably smaller subset of all columns of data, because reading that smaller subset of data can be faster than reading all data. A column-oriented DBMS can be designed to efficiently return data for an entire column, in as few operations as possible. A column-oriented DBMS can store data by serializing each column of data of data structure 400. For example, in a column-oriented DBMS, data associated with a category (e.g., consuming entity identification category 420) can be stored serially such that data associated with that category for all interactions of data structure 400 can be accessed in one operation.

As shown in FIG. 4, data structure 400 can comprise data associated with a very large number of interactions associated with multiple entities. For example, data structure 400 can include 50 billion or more interactions. In some embodiments, interactions associated with multiple entities can be referred to as transactions between multiple entities. Where appropriate, the terms interactions and transactions are intended to convey the same meaning and can be used interchangeably throughout this disclosure. While each interaction of data structure 400 is depicted as a separate row in FIG. 4, it will be understood that each such interaction can be represented by a column or any other known technique in the art. Each interaction data can include several categories of information. For example, the several categories can include, number category 410; consuming entity identification category 420; consuming entity location category 430; provisioning entity identification category 440; provisioning entity location category 450; type of provisioning entity category 460; interaction amount category 470; and time of interaction category 480. It will be understood that FIG. 4 is merely exemplary and that data structure 400 can include even more categories of information associated with an interaction.

Number category 410 can uniquely identify each interaction of data structure 400. For example, data structure 400 depicts 50 billion interactions as illustrated by number category 410 of the last row of data structure 400 as 50,000,000,000. In FIG. 4, each row depicting a interaction can be identified by an element number. For example, interaction number 1 can be identified by element 401; interaction number 2 can be identified by element 402; and so on such that interaction 50,000,000,000 can be identified by 499B. It will be understood that this disclosure is not limited to any number of interactions and further that this disclosure can extend to a data structure with more or fewer than 50 billion interactions. It is also appreciated that number category 410 need not exist in data structure 400.

Consuming entity identification category 420 can identify a consuming entity. In some embodiments, consuming entity identification category 420 can represent a name (e.g., User 1 for interaction 401; User N for interaction 499B) of the consuming entity. Alternatively, consuming entity identification category 420 can represent a code uniquely identifying the consuming entity (e.g., CE002 for interaction 402). For example, the identifiers under the consuming entity identification category 420 can be a credit card number that can identify a person or a family, a social security number that can identify a person, a phone number or a MAC address associated with a cell phone of a user or family, or any other identifier.

Consuming entity location category 430 can represent a location information of the consuming entity. In some embodiments, consuming entity location category 430 can represent the location information by providing at least one of: a state of residence (e.g., state sub-category 432; California for element 401; unknown for interaction 405) of the consuming entity; a city of residence (e.g., city sub-category 434; Palo Alto for interaction 401; unknown for interaction 405) of the consuming entity; a zip code of residence (e.g., zip code sub-category 436; 94304 for interaction 401; unknown for interaction 405) of the consuming entity; and a street address of residence (e.g., street address sub-category 438; 123 Main St. for interaction 401; unknown for interaction 405) of the consuming entity.

Provisioning entity identification category 440 can identify a provisioning entity (e.g., a merchant or a coffee shop). In some embodiments, provisioning entity identification category 440 can represent a name of the provisioning entity (e.g., Merchant 2 for interaction 402). Alternatively, provisioning entity identification category 440 can represent a code uniquely identifying the provisioning entity (e.g., PE001 for interaction 401). Provisioning entity location category 450 can represent location information of the provisioning entity. In some embodiments, provisioning entity location category 450 can represent the location information by providing at least one of: a state where the provisioning entity is located (e.g., state sub-category 452; California for interaction 401; unknown for interaction 402); a city where the provisioning entity is located (e.g., city sub-category 454; Palo Alto for interaction 401; unknown for interaction 402); a zip code where the provisioning entity is located (e.g., zip code sub-category 456; 94304 for interaction 401; unknown for interaction 402); and a street address where the provisioning entity is located (e.g., street address sub-category 458; 234 University Ave. for interaction 401; unknown for interaction 402).

Type of provisioning entity category 460 can identify a type of the provisioning entity involved in each interaction. In some embodiments, type of provisioning entity category 460 of the provisioning entity can be identified by a category name customarily used in the industry (e.g., Gas Station for interaction 401) or by an identification code that can identify a type of the provisioning entity (e.g., TP E123 for interaction 403). Alternatively, type of the provisioning entity category 460 can include a merchant category code (“MCC”) used by credit card companies to identify any business that accepts one of their credit cards as a form of payment. For example, MCC can be a four-digit number assigned to a business by credit card companies (e.g., American Express™, MasterCard™, VISA™) when the business first starts accepting one of their credit cards as a form of payment.

In some embodiments, type of provisioning entity category 460 can further include a sub-category (not shown in FIG. 4), for example, type of provisioning entity sub-category 461 that can further identify a particular sub-category of provisioning entity. For example, an interaction can comprise a type of provisioning entity category 460 as a hotel and type of provisioning entity sub-category 461 as either a bed and breakfast hotel or a transit hotel. It will be understood that the above-described examples for type of provisioning entity category 460 and type of provisioning entity sub-category 461 are non-limiting and that data structure 400 can include other kinds of such categories and sub-categories associated with an interaction.

Interaction amount category 470 can represent a transaction amount (e.g., $74.56 for interaction 401) involved in each interaction. Time of interaction category 480 can represent a time at which the interaction was executed. In some embodiments, time of interaction category 480 can be represented by a date (e.g., date sub-category 482; Nov. 23, 2013, for interaction 401) and time of the day (e.g., time sub-category 484; 10:32 AM local time for interaction 401). Time sub-category 484 can be represented in either military time or some other format. Alternatively, time sub-category 484 can be represented with a local time zone of either provisioning entity location category 450 or consuming entity location category 430.

In some embodiments, each interaction data can include categories of information including (not shown in FIG. 4), for example, consuming entity loyalty membership category, consuming entity credit card type category, consuming entity age category, consuming entity gender category, consuming entity income category, consuming entity with children category, product information category, and service information category.

Consuming entity loyalty membership category can represent whether the consuming entity is part of a loyalty membership program associated with a provisioning entity. For example, consuming entity loyalty membership category can represent that the consuming entity is a member of one of Costco™ membership programs including Goldstar Member™, Executive Member™, and Business Member™. Consuming entity credit card type category can represent the type of credit card used by the consuming entity for a particular interaction. For example, consuming entity credit card type category can indicate that the credit card used by the consuming entity for that particular interaction can be an American Express™, MasterCard™, VISA™, or Discover™ card. In some embodiments, consuming entity credit card type category can represent a kind of MasterCard™ (e.g., Gold MasterCard™ or Platinum MasterCard™) used for a particular interaction.

In some embodiments, consuming entity demographic information can be stored in each interaction. For example, consuming entity demographic information can include at least one of: consuming entity age category, consuming entity gender category, consuming entity income category, and consuming entity with children category. In some embodiments, consuming entity age category can represent age information associated with the consuming entity; consuming entity gender category can represent gender information (e.g., Male or Female) associated with the consuming entity; consuming entity income category can represent income information (e.g., greater than $100,000 per year) associated with the consuming entity; and consuming entity with children category can represent whether the consuming entity has any children under 18 or not. For example, if the consuming entity has children under 18, a positive indication can be stored and if the consuming entity does not has children under 18, a negative indication can be stored. In some embodiments, consuming entity with children category can store information representing a number of children associated with the consuming entity.

Product information category can represent information associated with a product that is involved in an interaction. For example, product information category can represent that the product involved in the interaction is a particular type of product based on a stock keeping unit (“SKU”) of the product. In some embodiments, the product's SKU can be unique to a particular provisioning entity involved in that particular interaction. Alternatively, product information category can represent the product involved in the interaction with a at least one of a Universal Product Code, International Article Number, Global Trade Item Number, and Australian Product Number. Service information category can represent information associated with a service that is involved in an interaction. For example, service information category can represent that the service involved in the interaction is a particular type of service based on an SKU of the service. It will be appreciated that an SKU can uniquely represent either a product or a service. Some examples of services can be warranties, delivery fees, installation fees, and licenses.

FIG. 5 is a block diagram of an exemplary scenario depicting a system for analyzing entity performance, consistent with embodiments of the present disclosure. System 500 depicts a scenario where a consuming entity (e.g., user of cell phone 505) can attempt to access a service at one or more provisioning entities (e.g., Website 1 542, Website 2 544, and/or Website 3 546). To access one of the provisioning entities, the consuming entity can initiate an access request from cell phone 505. The access request can include a consuming entity identification such as, for example, a cell phone number or a MAC address associated with cell phone 505. The access request can then reach a cellular base station 515 through a communication link 510. It will be understood that communication link 510 can either be a wireless link (as shown in the exemplary embodiment of FIG. 5) or a wired link (not shown). Next, the access request can reach server 525 through network 520. Network 520 can be, for example, the Internet. In some embodiments, network 520 can be one of either a local area network, a wide area network, or an entity's intranet. Server 525 can be a server located at a service provider (e.g., Verizon Wireless™). Server 525 can be, in some embodiments, an authentication, authorization, and accounting server (AAA server). In some embodiments, server 525 can be a proxy server that can facilitate a communication between cell phone 505 and a server device at the provisioning entities (e.g., Website 1 542).

Access request can reach one of the provisioning entities after an authorization, authentication, and accounting process is complete. Access request can traverse to one of the provisioning entities through network 530. Network 530 can be similar to network 520, as described above. After the authorized and authenticated access request reaches one of the provisioning entities, the consuming entity is allowed to access the provisioning entities. In this exemplary embodiment, user of cell phone 505 can access either Website 1 542, Website 2 544, or Website 3 546, depending on details of the access request. For example, provisioning entities can be one of the websites Google™, Facebook™, and Twitter™.

After a consuming entity (e.g., user of cell phone 505 or cell phone 505) accesses one of the provisioning entities, server 525 can store information regarding the user and/or cell phone accessing these provisioning entities. Each access by a user of a website can be stored as an interaction in a data structure in Server 525. Server 525 can store such information in a data structure (e.g., data structure 400) comprising several categories of information including, but not limited to, an interaction number; consuming entity identification; consuming entity location; provisioning entity identification; provisioning entity location; type of provisioning entity; duration of interaction; and time of interaction. The data structure can be analyzed by a data computation system (which can also be included in server 525 or similar devices) to analyze a performance of provisioning entities, for example, to estimate a number of unique consuming entities (e.g., users) per month, average amount of time a consuming entity spends on their website, time of the day where consuming entity traffic is highest or lowest, etc. It will be understood that any number of useful insights can be drawn by analyzing the data structure comprising interactions associated with consuming entities and provisioning entities. While FIG. 5, depicts a use case scenario of a cell phone user (exemplary consuming entity) accessing a website (exemplary provisioning entity), it will be understood that a process of analyzing interaction between a consuming entity and a provisioning entity can be extended to any number of scenarios, including, financial transactions between consumers and banks; credit card transactions between a consumer and a provisioning entity like a grocery store, movie theatre, gas station, mall, etc.

As described above, embodiments of the invention relate to analyzing entity performance in real-time based on interactions (e.g., anonymized credit card or debit card transaction data) and potentially other data (e.g., merchant data). In many ways, embodiments herein are related to U.S. patent application Ser. No. 14/306,138, entitled Methods and Systems for Analyzing Entity Performance, which is incorporated herein by reference.

FIG. 6 is a block diagram of an exemplary system 600 for analyzing entity performance, consistent with the embodiments of the present disclosure. System 600 may include a server 610, a network 620, transaction data 630, and point-of-sale (PoS) data 640. In various embodiments, transaction data 630 can include, but is not limited to: card numbers, an issuing bank, a third party processor, a card association, a name, address, zip code, email address, or phone number associated with consuming entity, an address associated with a merchant, a type of provisioning entity (e.g., a pizza store), etc. Transaction data 630 and PoS data 640 can be sent over network 620 to server 610 for processing. Server 610, can act substantially similarly to server 525 of FIG. 5. For example, it can store a data structure and a data computation system, and/or server 610 can comprise multiple electronic devices, etc. As will be discussed below, transaction data 630 and PoS data can be included in a variety of storage devices, and transmitted to server 610 in real-time or near real-time.

Large sets of interaction data can be filtered in real-time or near real-time, according to criteria to provide information associated with the performance of a particular provisioning entity (e.g., a merchant, a retail provisioning entity, or the like) as described with reference to FIGS. 4, 5, and 6. As described above, consuming entities can include a purchaser of products or services. It should, however, be noted that in some embodiments an entity can be both a consuming entity and a provisioning entity.

In various embodiments, information associated with interactions (also referred to as transactions) are stored in one or more databases such as Vertica™ or Oracle™, which can be stored in server 610. Some databases—whether row based or column based—are not suited well for high user scale or pre-computing large amounts of information, such as aggregation of information associated with interactions (referred to herein as an aggregate, aggregation, or information associated with one entity or a cohort of entities). An aggregate can be used to render information, such as statistics, time, and money on the display of one or more electronic devices with a graphical user interface, for example, as shown in FIG. 4. In various embodiments, an aggregate can be computed once a week, once a day, less than every 15 minutes, less than every 5 minutes, or in real-time (or at least near real-time) by a data computation system, which can also be stored in server 610. Aggregates can be created by running queries (predefined or otherwise) on a data structure such as a data structure 400. Data computation systems used to create aggregates may use a variety of programming languages, such as Java, C, C++, etc., and store those aggregates in a data structure such as a distributed file system. Further, creating aggregates (e.g., processing queries) can be performed in parallel.

As described above, examples of an aggregate can include, but are not limited to: how much revenue a provisioning entity collected in a day; information representing market share of one or more provisioning entities in comparison to one or more other provisioning entities; location information; information representing wallet share associated with one or more provisioning entities and wallet share associated with one or more other provisioning entities (wherein wallet share includes a cost or time associated with an entity, such as how much money a consuming entity spent in a day at one or more provisioning entities and times associated therewith); etc. Other examples of data included in an aggregate (e.g., data used to create a cohort) can be found in U.S. patent application Ser. No. 14/306,138, as referenced above and incorporated in its entirety herein.

By using real-time data (also referred to as streaming data) or near real-time data to create an aggregate, a user can determine information associated with various aggregates each hour of the day, week, etc. This data can be acquired from transaction data 630, PoS data 640, or both. Further, aggregates can have varying degrees of granularity, such that a user may see the behavior of various consuming entities within the previous 15 minutes, for example. As another example, by using a data computation system that updates frequently, a user may be able to view a display on a mobile device (e.g., smartphone, wearable computer, etc.) to see how and where consuming entities are while the user is away from their office during a weekend. As yet another example, a user can view the last hundred transactions at a particular provisioning entity, or the last hundred transactions at a plurality of provisioning entities (including what products were purchased). In some embodiments, a user can view aggregates associated with a particular time. For instance, embodiments described herein can allow a user to view aggregates, such as revenue or types of products sold, during a particular time during the previous week. Various user interfaces described herein such as in FIG. 4 and in U.S. patent application Ser. No. 14/306,138 can display a plurality of aggregates, which can include various cohorts of consuming and/or provisioning entities and information associated therewith.

In some embodiments, the interactions are processed using a data computation system (which can be a part of a real-time distributed computation environment) that supports stream-oriented processing. In some embodiments, the data structure storing the interactions is incrementally updated at particular intervals, to provide a user with real-time information about the interactions. Example data computation systems include Apache's Spark™ or Storm™, which can operate in conjunction with the Hadoop Distributed File System and/or Amazon™ S3 which can store data structures that include transaction data, stream data, and other data discussed throughout this disclosure. Distributed file systems can store data which Apache's Spark™ uses to compute aggregates, cohorts, and the like. Example systems can be stored on hardware including one or more computers/servers, and/or other multi-tenant environments comprising hardware (e.g., servers 525 or 610).

In various embodiments described herein, multiple streams of data can be acquired, stored, and used by a data computation system to produce aggregates. These streams can be acquired from transaction data 630, PoS data 640, or both. Further, in some embodiments streams of data can be used to create smaller streams of data (sub-streams). For instance, a stream can be segmented by information associated with one or more particular provisioning entities or consuming entities. In some embodiments, thousands, or hundreds of thousands of sub-streams can be processed using embodiments described herein.

In examples described below, a first stream that includes data associated with credit card and/or debit card transactions can be acquired (e.g., from transaction data 630) along with a second stream that includes data associated with a particular PoS system (e.g., from PoS data 640). Information from these streams can be compared, combined, and/or otherwise modified to produce data and statistics included in aggregates in real or near-real time, which can subsequently be displayed to a user.

A first stream of data including information associated with credit and debit card interactions can include over three-hundred million transactions per day, for example. This stream can include information associated with a location, a provisioning entity, a consuming entity, a Merchant Category Code (MCC), other information mentioned above with respect to FIG. 4, etc. Such a stream can also be divided into smaller streams, for instance, by provisioning entity (e.g., a merchant).

In addition, a second stream can be acquired that includes interaction information from a PoS system. Again, such a stream can be segmented into a variety of different streams, or additional streams can be acquired in various embodiments. Some PoS systems can acquire data such as goods or services purchased by a consuming entity. In various embodiments, PoS systems acquire less, the same, similar, or more data than a stream associated with credit card and/or debit cards. PoS systems can acquire (and subsequently transmit) information including, but not limited to: information indicative of products that are selling the most in the store (either by volume or revenue); information associated with the profits associated with various objects sold; information associated with a consuming entity (such as their identity, home location, billing address, etc.); information associated with the location of products in a store (e.g., their position in a physical location); information associated with cash (e.g., paper money) or other currency used at the PoS; information associated with bitcoin or other virtual currency used at the PoS; the number of consuming entities serviced by the PoS system; credit cards or debit cards used at the PoS; metadata associated with credit cards, debit cards, or virtual currency used at a PoS; information associated with purchases that involved more than one payment type (e.g., splitting a payment over two credit cards, or partially paying for a good or service with cash); an average amount of money that a plurality of consuming entities spend at a particular PoS system or provisioning entity; data indicating how frequently a consuming entity makes a transaction at a provisioning entity, and the frequency with which one or more consuming entities purchase one or more particular products; etc. PoS systems can also use various software and/or hardware systems to stream information to a data structure, as described above.

In some embodiments, data streams can be segmented to include information associated with new customers, returning customers (e.g., consuming entities that make a purchase at a provisioning entity at least twice within a particular amount of time), determining a home location associated with an individual based on transaction data (e.g., anonymized credit card transaction data), local customers, and non-local customers (e.g., a customer that lives at least a particular distance from the provisioning entity that the customer is making a purchase at). The aggregation of interaction information associated with these streams can be incrementally updated in a data structure (e.g., a distributed file system) in real-time, allowing a user to access a business portal and view a day-by-day, year-by-year, or even minute-by-minute break down of revenues generated, locations of interactions, etc. Of course, all of the above-mentioned functions can be performed by a data

As noted above, in various embodiments one or more electronic devices can process the data included in the data streams. For example, one or more electronic devices hosting a data computation system (such as Apache's Spark™) can process the data. Various approaches can be implemented to process the data.

For example, all relevant acquired and/or stored data from a stream can be processed by one or more electronic devices to produce one or more aggregates (referred to herein as a batch process). In some cases, a portion of the acquired and/or stored data from a stream can be processed by one or more electronic devices. For instance, an electronic device can produce aggregates from data including previously produced aggregates. In such embodiments, it is possible for a device to incrementally update aggregates as additional information is acquired (e.g., from one or more streams of data).

Various approaches may be useful based on the type of task performed. For example, if previously collected data needs to be edited, if a new aggregate is created (e.g., a new query is added to create or modify aggregates), and/or another update/modification to the embodiments described herein is introduced, then a batch process may be performed (e.g., wherein queries are ran on all of the relevant data in the data structure).

Numerous queries can be run on a data structure using a data processing system. Example queries can include, but are not limited to: customer visits (e.g., a query that is used to compute a the number of new and returning customers that have visited a particular merchant over various time periods (last X days, last Y weeks, last Z months, last W years, etc.); travel distance (e.g., a query that is used to compute a histogram over the distances that customers have traveled to visit a merchant; visit frequency (e.g., a query that is used to compute a histogram over the number of times that a customer has visited a merchant); return statistics (e.g., a query that is used to compute a histogram over the number of days that it took a customer to return a merchant after his/her last visit; busiest days (e.g., a query that is used to compute a histogram showing revenue and transaction counts broken down by day of week such as Sunday through Saturday); busiest hours (e.g., a query that is used to compute a histogram showing revenue and transaction counts broken down by hour of day; daily transactions (e.g., a query that is used to compute a histogram showing revenue and transaction counts broken down by date); minutely transactions (e.g., a query that is used to compute a histogram showing revenue and transaction counts broken down by minute); customer home location map (e.g., a query that is used to compute a heatmap/choropleth showing inferred customer home locations for a merchant); customer spend map (e.g., a query that is used to compute a heatmap/choropleth showing inferred customer spend locations for a merchant); revenue by payment type (e.g., a query that is used to compute a histogram showing revenue and transaction counts broken down by payment type (e.g., credit vs. cash)); sales numbers (e.g., a query that is used to compute total revenue, number of distinct orders, number of distinct customers, and number of sold units over a given time period); item numbers (e.g., a query that is used to compute histogram of revenue, order count, customer count, and unit count broken down by item SKU); accompanying items (e.g., a query that is used to compute histogram of revenue, order count, customer count, and unit count broken down by pairs of item SKUs that have been bought together); recent transactions (e.g., a query that is used to compute a rolling history of the K most recent transactions in a given time period), etc.

In some embodiments, where the aggregates are incrementally updated, a batch process may not be necessary. For instance, data acquired from a stream can be processed along with previously acquired data (e.g., data that has already been used to produce an aggregate) to provide a user with information faster than if the aggregates were to be created using all of the data, as with a batch process. In various embodiments, predetermined queries can be run on data that has not been used to create an aggregate along with previously created aggregates. It should be appreciated that the previously aggregated data can include hundreds of millions of transactions and data associated therewith. Thus, incrementally modifying aggregates can reduce processing time and the amount of resources required (e.g., memory, processing power, etc.), resulting in improvements to traditional computers. Further, incrementally modifying aggregates allows users to view the updated aggregates in real or near-real time.

In some embodiments, a PoS system may be installed, replaced, changed, or otherwise modified. In such a case, a typical user does not want to only be able to see aggregates (e.g., sales, revenue, etc.) beginning at the point in time that the PoS system was installed (or when the PoS system started being used). Users typically want to see historical data predating the PoS system. In such a case, a stream can be acquired that contains additional information, such as information from before a new PoS system is installed.

In some embodiments, a covert stream can be processed. A covert stream can include two or more streams (e.g., it can include a blended stream). For instance, when a new PoS system is installed or otherwise reset such that it does not have access to historical data, in addition to the stream of data acquired from the PoS system, another stream of data can be acquired. In such a case, the data from a first stream that includes information associated with credit cards and/or debit cards can be blended with the data generated by the PoS system. In some embodiments, information associated with a cohort (e.g., a group of entities), can be provided to a user based on data associated with an entity. In some cases, data associated with an entity such as an MCC, a location, the size of the entity or other criteria can be used to determine a cohort, and information associated with that cohort can be provided to a user. For instance, this information can be used to compare sales with a similar entity.

Information can be provided in a variety of methods. For instance, aggregates or other data can be provided via email, or when a user logs on to a web portal. Emails or information provided via a website can include summaries of data, such as interesting information associated with transactions that occurred during a previous week, month, or year. These summaries can be preformatted (e.g., to include information about a previous week's revenue). In some cases, one or more different aggregates can be selected and viewed by a user.

FIG. 7 is an illustration of an example display 700, consistent with the embodiments of the present disclosure. In various embodiments, data generated by a data processing system can be used to create various illustrations. For example, display 700 illustrates a display 700 that discloses an average amount of money spent at various entities up to 15 minutes ago. Of course, in various embodiments, such illustrations, graphs or other types of displays based on data processed by the data processing system can be updated in real- or near-real-time, as discussed above. As the example in display 700 illustrates, entities 710A, 710B, and 710C had a greater average revenue up to 15 minutes ago than entities 720A, 720B, or 720C, which in turn had a greater average revenue than entities 730A or 730B. This is shown by the indicator bar on the right that shows the relative revenues of entities with the shading of boxes 740, 750, and 760. Of course, a number of different queries can be run on a data processing system to determine other attributes of entities, such as an average revenue in the last week, day, hour, etc. Further, as mentioned above, various graphs, maps, pie charts, textual displays, types of stores, etc. can be displayed in a display such as 700 based at least in part on the data processed by a data processing system such as Apache's Spark™.

FIG. 8 is a flowchart 800 representing an exemplary process for querying a data structure, consistent with embodiments of the present disclosure. Flowchart 800 starts at step 810 and at step 820 acquires a first set of data and stores it in a data structure. For example, the first set of data can be transaction data (e.g., data associated with a card transaction such as a card number), and be inserted into a data store (distributed or otherwise) such as Hadoop's Distributed File System, Vertica™, or Amazon™ S3. This data can be acquired from transaction data 630, PoS data 640, or both. As described above and in the patent associated by reference herein, the data in the data structure can include interactions between entities. For example, it may include an interaction between a consuming entity and a provisioning entity. In various embodiments, transaction data can be pulled from the data store into a computation system (distributed or otherwise), such as Apache's Spark™.

As discussed above, in various embodiments a data computation system can process data and produce or update a plurality of aggregates, which after being computed are stored in a data store, which may include the data store that the transaction data was stored in. For example, at step 830, a plurality of queries can be created and/or registered, and can be used to process data and produce or update aggregates. Queries may be used to extract particular data out of the data structure based on various attributes associated with the data in the data structure. These attributes can include the location of an entity, the estimated location of an entity, an amount of revenue associated with an entity, an amount of money in an entity's bank account, the name of an entity's bank, the age of an entity, people associated with an entity, etc.

At step 840, a second set of data is acquired. Similarly, this data can be pulled from a data store, which may be a different data store or the same data store that the first set of data was pulled from. The second set of data may be collected and/or added to the data structure before or after a set of queries are created and/or registered. This second set of data can include interactions, or attributes associated with interactions.

At step 850, the data structure is modified to include the second set of data. As such, the data structure can include both the first set of data and the second set of data. Of course, additional sets of data can be collected and stored in addition to the second set of data. Also, additional data can be tagged. For instance, a set of data added on a particular date can be tagged with a unique identifier (e.g., the date).

At step 860, the modified data structure is queried using the plurality of queries created and/or registered. As mentioned above, these queries may be registered before the second set of data is acquired or added to the data structure. In any event, the data derived from the query can be provided to an electronic device (e.g., via a network), or otherwise displayed to a user. In some embodiments, an electronic device can create a web-consumable version of the aggregates. Aggregates can be used to generate and/or modify a key-value store (e.g., Apache's Cassandra™ and/or Elasticsearch), where they can be accessed by the various front-end pieces of code. After being accessed, aggregates (or portions thereof) can be displayed to a user.

At step 870 flowchart 800 ends.

Embodiments of the present disclosure have been described herein with reference to numerous specific details that can vary from implementation to implementation. Certain adaptations and modifications of the described embodiments can be made. Other embodiments can be apparent to those skilled in the art from consideration of the specification and practice of the embodiments disclosed herein. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the present disclosure being indicated by the following claims. It is also intended that the sequence of steps shown in figures are only for illustrative purposes and are not intended to be limited to any particular sequence of steps. As such, it is appreciated that these steps can be performed in a different order while implementing the exemplary methods or processes disclosed herein. 

1. A system comprising: one or more computer processors; one or more computer memories; a set of instructions incorporated into the one or more computer memories, the set of instructions configuring the one or more computer processors to perform operations for displaying an aggregate in at least near-real-time in a user interface, the facilitating including reducing an amount of processing time required to perform the displaying of the aggregate by incrementally updating the aggregate, the operations comprising: producing the aggregate by running a query on a data structure storing a first set of data relating to interactions performed by a plurality of entities; creating a modified data structure based on the data structure, the modified data structure including a second set of data relating to the interactions performed by the plurality of entities into the aggregate; and based on the incremental updating of the aggregate, running the query on the modified data structure and modifying the user interface in at least near-real time to include at least some of the second set of data.
 2. The system of claim 1, wherein the data structure is stored in random access memory of a cluster computing framework configured to process data within the data structure in at least near real-time.
 3. The system of claim 1, wherein the first set of data is segmented by new customers and returning customers by determining whether a consuming entity identified in the first set of data or the second set of data has made multiple purchases within a predetermined amount of time.
 4. The system of claim 1, wherein the first set of data and the second set of data are segmented by local customers and non-local customers by comparing a home address of a consuming entity with the first set of data or the second set of data.
 5. The system of claim 1, wherein the second set of data corresponds to a consuming entity and at least one of a set of consuming entity categories, the consuming entity categories including at least one of identification, location, loyalty, credit card type, age, gender, income, children, product information, and service information.
 6. The system of claim 1, where the second set of data is used to determine a cohort and the modifying of the user interface includes updating a comparison of entities in the cohort.
 7. The system of claim 1, wherein the incremental updating of the aggregate includes running the query on the second set of data as it is acquired from a data stream after the producing of the aggregate.
 8. A method comprising: performing operations for displaying an aggregate in at least near-real-time in a user interface, the facilitating including reducing an amount of processing time required to perform the displaying of the aggregate by incrementally updating the aggregate, the operations comprising: producing the aggregate by running a query on a data structure storing a first set of data relating to interactions performed by a plurality of entities; creating a modified data structure based on the data structure, the modified data structure including a second set of data relating to the interactions performed by the plurality of entities into the aggregate; and based on the incremental updating of the aggregate, running the query on the modified data structure and modifying the user interface in at least near-real time to include at least some of the second set of data.
 9. The method of claim 8, wherein the data structure is stored in random access memory of a cluster computing framework configured to process data within the data structure in at least near real-time.
 10. The method of claim 8, wherein the first set of data is segmented by new customers and returning customers by determining whether a consuming entity identified in the first set of data or the second set of data has made multiple purchases within a predetermined amount of time.
 11. The method of claim 8, wherein the first set of data and the second set of data are segmented by local customers and non-local customers by comparing a home address of a consuming entity with the first set of data or the second set of data.
 12. The method of claim 8, wherein the second set of data corresponds to a consuming entity and at least one of a set of consuming entity categories, the consuming entity categories including at least one of identification, location, loyalty, credit card type, age, gender, income, children, product information, and service information.
 13. The method of claim 8, where the second set of data is used to determine a cohort and the modifying of the user interface includes updating a comparison of entities in the cohort.
 14. The method of claim 8, wherein the incremental updating of the aggregate includes running the query on the second set of data as it is acquired from a data stream after the producing of the aggregate.
 15. A non-transitory computer-readable medium storing a set of instructions that are executable by one or more processors of an apparatus to cause the apparatus to perform operations for displaying an aggregate in at least near-real-time in a user interface, the facilitating including reducing an amount of processing time required to perform the displaying of the aggregate by incrementally updating the aggregate, the operations comprising producing the aggregate by running a query on a data structure storing a first set of data relating to interactions performed by a plurality of entities; creating a modified data structure based on the data structure, the modified data structure including a second set of data relating to the interactions performed by the plurality of entities into the aggregate; and based on the incremental updating of the aggregate, running the query on the modified data structure and modifying the user interface in at least near-real time to include at least some of the second set of data.
 16. The non-transitory computer-readable medium of claim 15, wherein the data structure is stored in random access memory of a cluster computing framework configured to process data within the data structure in at least near real-time.
 17. The non-transitory computer-readable medium of claim 15, wherein the first set of data is segmented by new customers and returning customers by determining whether a consuming entity identified in the first set of data or the second set of data has made multiple purchases within a predetermined amount of time.
 18. The non-transitory computer-readable medium of claim 15, wherein the first set of data and the second set of data are segmented by local customers and non-local customers by comparing a home address of a consuming entity with the first set of data or the second set of data.
 19. The non-transitory computer-readable medium of claim 15, wherein the second set of data corresponds to a consuming entity and at least one of a set of consuming entity categories, the consuming entity categories including at least one of identification, location, loyalty, credit card type, age, gender, income, children, product information, and service information.
 20. The non-transitory computer-readable medium of claim 15, where the second set of data is used to determine a cohort and the modifying of the user interface includes updating a comparison of entities in the cohort. 